home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / OrdColl.C < prev    next >
C/C++ Source or Header  |  1990-12-04  |  6KB  |  348 lines
  1. //$OrdCollection,OrdCollectionIter,RevOrdCollectionIter$
  2. #include "OrdColl.h"
  3. #include "Error.h"
  4. #include "FixedStorage.h"
  5.  
  6. const int cOrdColShrinkFactor = 2,
  7.       cMinExpand = 8;
  8.  
  9. //---- ordered collection ------------------------------------------------------
  10.  
  11. MetaImpl(OrdCollection, (TP(cont), 0));
  12.  
  13. static void ObjNotFound(char *where, Object *which)
  14. {
  15.     Error(where, "object (0x%x) not found", (int) which);
  16. }
  17.  
  18. OrdCollection::OrdCollection(int s)
  19. {
  20.     cont= new ObjArray(s);
  21.     size= 0;
  22. } 
  23.  
  24. OrdCollection::~OrdCollection()
  25. {
  26.     SafeDelete(cont);
  27. }
  28.  
  29. void OrdCollection::InitNew()
  30. {
  31.     cont= new ObjArray(cCollectionInitCap);
  32.     size= 0;
  33. }
  34.  
  35. void OrdCollection::FreeAll()
  36. {
  37.     for (int i= 0; i < size; i++) {
  38.     Object *op= cont->At(i);
  39.     if (op) {
  40.         op->FreeAll();
  41.         SafeDelete(op);
  42.     }
  43.     }
  44.     size= 0;
  45. }
  46.  
  47. ObjPtr OrdCollection::At(int index)
  48. {
  49.     if (index < 0 || index >= size)
  50.     Error ("At", "illegal index %d (size= %d)", index, size);
  51.     if (!AnyDeleted())
  52.     return cont->UncheckedAt(index);
  53.  
  54.     // take care of deleted objects
  55.     return SeqCollection::At(index);
  56. }
  57.  
  58. ObjPtr OrdCollection::After(ObjPtr op)
  59. {
  60.     if (op == 0) 
  61.     return 0;
  62.     int i= cont->IndexOf(op);
  63.     if (i == -1) { 
  64.     ObjNotFound("After", op);
  65.     return 0;
  66.     }
  67.     if (i == size-1)
  68.     return 0;    
  69.     return cont->At(i+1);
  70. }
  71.  
  72. ObjPtr OrdCollection::Before(ObjPtr op)
  73. {
  74.     if (op == 0) 
  75.     return 0;
  76.     int i= cont->IndexOf (op);
  77.     if (i == -1) { 
  78.     ObjNotFound("Before", op);
  79.     return 0;
  80.     }
  81.     if (i == 0)
  82.     return 0;    
  83.     return cont->At(i-1);
  84. }
  85.  
  86. ObjPtr OrdCollection::First()
  87. {
  88.     return At(0);
  89. }
  90.  
  91. ObjPtr OrdCollection::Last()
  92. {
  93.     int i;
  94.     Object *op;
  95.  
  96.     for (i= Size()-1; i >= 0; i--) {
  97.     op= cont->At(i);
  98.     if (!op->IsDeleted())
  99.         return op;
  100.     }
  101.     return 0;
  102. }
  103.  
  104. int OrdCollection::Capacity()
  105. {
  106.     return cont->Size();
  107. }
  108.  
  109. ObjPtr OrdCollection::Add(ObjPtr op)
  110. {
  111.     if (CheckNotNull("Add", op))
  112.     return 0;
  113.     AddAt(size, op);
  114.     return 0;
  115. }
  116.  
  117. void OrdCollection::InsertAtPos(ObjPtr at, ObjPtr op, bool byPtr, bool after, char *name) 
  118. {
  119.     if (CheckNotNull(name, op))
  120.     return;
  121.     if (cont->Size() <= 0)
  122.     return;
  123.     CheckActiveIter(name);
  124.     int i;
  125.     if (byPtr)
  126.     i= cont->IndexOfPtr(at);
  127.     else
  128.     i= cont->IndexOf(at);
  129.     if (i == -1) 
  130.     ObjNotFound(name, op);
  131.     if (after)
  132.     i++;
  133.     AddAt(i, op);
  134. }
  135.  
  136. void OrdCollection::InsertAfter(ObjPtr after, ObjPtr op)
  137. {
  138.     InsertAtPos(after, op, FALSE, TRUE, "InsertAfter");
  139. }
  140.  
  141. void OrdCollection::InsertAfterPtr(ObjPtr after, ObjPtr op)
  142. {
  143.     InsertAtPos(after, op, TRUE, TRUE, "InsertAfterPtr");
  144. }
  145.  
  146. void OrdCollection::InsertBefore(ObjPtr before, ObjPtr op)
  147. {
  148.     InsertAtPos(before, op, FALSE, FALSE, "InsertBefore");
  149. }
  150.  
  151. void OrdCollection::InsertBeforePtr(ObjPtr before, ObjPtr op)
  152. {
  153.     InsertAtPos(before, op, TRUE, FALSE, "InsertBeforePtr");
  154. }
  155.  
  156. ObjPtr OrdCollection::Remove(ObjPtr e)
  157. {
  158.     register ObjPtr t= 0;
  159.  
  160.     if (e == 0) 
  161.     return 0;
  162.     for (int i= 0; i < size; i++) {
  163.     Object* tmp; // g++ ??
  164.     tmp= cont->At(i);
  165.     if (e->IsEqual(tmp))
  166.         t= DoRemoveAt(i);
  167.     }
  168.     return t;
  169. }
  170.  
  171. ObjPtr OrdCollection::RemovePtr(ObjPtr e)
  172. {
  173.     register ObjPtr t= 0;
  174.  
  175.     if (e == 0) 
  176.     return 0;
  177.     for (int i = 0; i < size; i++)
  178.     if (e == cont->At(i))
  179.         t= DoRemoveAt(i);
  180.     return t;
  181. }
  182.  
  183. void OrdCollection::AddAt(int at, ObjPtr op)
  184. {
  185.     register int j;
  186.  
  187.     if (CheckNotNull("AddAt", op))
  188.     return;
  189.     CheckActiveIter("AddAt");
  190.     if (at > size)
  191.     Error("AddAt", "out of range");
  192.     if (size == cont->Size())
  193.     cont->Expand (GrowBy(max(cont->Size(), cMinExpand)));
  194.     for (j= size-1; j >= at; j--)
  195.     (*cont)[j+1]= (*cont)[j];
  196.  
  197.     (*cont)[at]= op;
  198.     size++;
  199.     Changed();
  200. }
  201.  
  202. ObjPtr OrdCollection::RemoveAt(int i)
  203. {
  204.     if (!AnyDeleted())
  205.     return DoRemoveAt(i);
  206.     return RemovePtr(At(i));
  207. }
  208.  
  209. ObjPtr OrdCollection::DoRemoveAt(int i)
  210. {
  211.     ObjPtr t;
  212.     register int j;
  213.  
  214.     t= cont->RemoveAt(i);
  215.     if (InIterator()) {
  216.     cont->AtPut (i, new DeletedObject);
  217.     AnnounceRemove();
  218.     Changed();
  219.     return t;
  220.     }
  221.     for (j= i; j < size-1; j++)
  222.     cont->AtPut(j, cont->At(j+1));
  223.     cont->AtPut(size-1, 0);
  224.     
  225.     size--;
  226.     if (LowWaterMark()) 
  227.     cont->Expand (cont->Size() / cOrdColShrinkFactor);
  228.     
  229.     Changed();
  230.     return t;
  231. }
  232.  
  233. void OrdCollection::RemoveDeleted()
  234. {
  235.     Object *op;
  236.     for (int j= 0; j < size;) {
  237.     op= cont->At(j);
  238.     if (op && op->IsDeleted()) {
  239.         DoRemoveAt(j);
  240.         SafeDelete(op);
  241.     }
  242.     else 
  243.         j++;
  244.     }
  245. }
  246.  
  247. void OrdCollection::Empty (int s)                                         
  248. {
  249.     CheckActiveIter("Empty");
  250.     SafeDelete(cont);
  251.     cont= new ObjArray(max(s,4)); 
  252.     size= 0; 
  253. }
  254.  
  255. Iterator *OrdCollection::MakeIterator() 
  256. { 
  257.     return new OrdCollectionIter(this); 
  258. }
  259.  
  260. Iterator *OrdCollection::MakeReversedIterator () 
  261. { 
  262.     return new RevOrdCollectionIter(this); 
  263. }
  264.  
  265. void OrdCollection::Sort()
  266. {
  267.     CheckActiveIter("Sort");
  268.     cont->Sort(size);
  269. }
  270.  
  271. int OrdCollection::BinarySearch(ObjPtr op)
  272. {
  273.     return cont->BinarySearch(op, size);
  274. }
  275.  
  276. //---- ordered collection iterator ---------------------------------------------
  277.  
  278. OrdCollectionIter::OrdCollectionIter(Collection *s)
  279. { 
  280.     cs= (OrdCollection *)s;
  281.     ce= 0; 
  282. }
  283.  
  284. OrdCollectionIter::~OrdCollectionIter()
  285. {
  286.     IteratorEnd();
  287. }
  288.  
  289. void OrdCollectionIter::Reset(Collection *s)
  290. {
  291.     if (s == 0)
  292.     s= Coll();
  293.     cs= (OrdCollection *)s;
  294.     ce= 0;
  295.     Iterator::Reset(s);
  296. }
  297.  
  298. Collection *OrdCollectionIter::Coll()
  299. {
  300.     return cs;
  301. }
  302.  
  303. ObjPtr OrdCollectionIter::operator()()
  304. {
  305.     IteratorStart();
  306.     // find next non deleted object
  307.     for ( ;ce < cs->Size() && cs->cont->UncheckedAt(ce)->IsDeleted(); ce++)
  308.     ;
  309.     if (ce < cs->Size()) 
  310.     return cs->cont->UncheckedAt(ce++);
  311.     IteratorEnd();
  312.     return 0;
  313. }
  314.  
  315. void *OrdCollectionIter::operator new(size_t sz)
  316. {
  317.     return MemPools::Alloc(sz);
  318. }
  319.  
  320. void OrdCollectionIter::operator delete(void *vp)
  321. {
  322.     MemPools::Free(vp, sizeof(OrdCollectionIter)); 
  323. }
  324.  
  325. //---- RevOrdCollectionIter ----------------------------------------------------
  326.  
  327. RevOrdCollectionIter::RevOrdCollectionIter(Collection *s) : OrdCollectionIter(s)
  328. {
  329.     ce= cs->Size()-1;
  330. }
  331.  
  332. void RevOrdCollectionIter::Reset(Collection *s)
  333. {
  334.     OrdCollectionIter::Reset(s);
  335.     ce= cs->Size()-1;
  336. }
  337.  
  338. ObjPtr RevOrdCollectionIter::operator()()
  339. {
  340.     IteratorStart();
  341.     // find next non deleted object
  342.     for (; ce >= 0 && cs->cont->At(ce)->IsDeleted(); ce--);
  343.     if (ce >= 0) 
  344.     return cs->cont->UncheckedAt(ce--);
  345.     IteratorEnd();
  346.     return 0;
  347. }
  348.